home *** CD-ROM | disk | FTP | other *** search
/ Hacker's Arsenal - The Cutting Edge of Hacking / Hacker's Arsenal - The Cutting Edge of Hacking.iso / files / irc / scripts / lame.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-01-31  |  4.0 KB  |  159 lines
  1. /*
  2.     S0 U wAnt t() be laMe?
  3.  
  4.      Yezz, this 1s Y3t AN()th3r T3xt f1lTer f()r U LameRs t() us3.  It
  5.     sH0uLd C0mp1le 0N alm0ST any mAcHin3 that isn'T t0() lame.  Us3 IT
  6.     t0 lAm3R1ze Ur teXT wh3n ()n chat sYSt3mzz, usE 1t t() lam3r1ze
  7.     Ur emA1L, hecK, uSe 1t T() lam3R1Ze wh()lE B00KS.
  8.  
  9.     1F U're S0 lame tHAt U nEed h3Lp, type
  10.         lame -h
  11.     & Th3 |ame pr0gRam Will G1ve a hElp scrEen.
  12.  
  13. */
  14.     
  15. /**********
  16.  **********  The Lame Filter                Version 2.7.lame.lame.lame
  17.  **********  by zorgo <zorgo@gnu.ai.mit.edu>    07/11/93 
  18.  **********
  19.  **********  This code is too lame to be Commercial,
  20.  **********  too lame to be Shareware,
  21.  **********  too lame to be Public Domain,
  22.  **********  too lame to be GNU copylefted, 
  23.  **********  it's Lameware!
  24.  **********
  25. **********/
  26.  
  27. #define MAXLAME 1000
  28. /* #define LAME_SRAND 1 */
  29. /* Some lamers have complained that 'time_t t' definition for srand
  30.    barfed on compile, so now we use lame getpid() in srand 
  31.    UNLESS you define LAME_SRAND */
  32.  
  33. #include <stdio.h>
  34. #include <ctype.h>
  35.  
  36. #ifdef LAME_SRAND
  37. #include <time.h>
  38. #endif
  39.  
  40. void main(argc, argv)
  41. int argc;
  42. char *argv[];
  43. {
  44.     register int i;
  45.     char buf[MAXLAME];
  46.  
  47.     if(argc > 1) {
  48.         if( *argv[1]=='-' ) {
  49.             usage();
  50.             exit();
  51.         }
  52.         for(i=1; i<argc; i++) {
  53.             sprintf(buf, "%s ", argv[i]);
  54.             lamerize(buf);
  55.         }
  56.         printf("\n");  /* for lame unix */
  57.         exit();
  58.     }
  59.  
  60.     lame();
  61.     exit();
  62. }
  63.  
  64. /********************************************************************/
  65. /********************************************************************/
  66. lame()
  67. {
  68.     char ch, ch_buf[MAXLAME];
  69.     register int i;
  70.  
  71.     ch_buf[0] = NULL;
  72.  
  73.     while(1) {
  74.         ch = fgetc(stdin);
  75.         if( ch == EOF ) return(-1);
  76.         strncat(ch_buf, &ch, 1);
  77.  
  78.         if(ch=='\n') {
  79.             lamerize(ch_buf);
  80.             for (i=0; i<strlen(ch_buf); i++) {
  81.                 ch_buf[i] = NULL;
  82.             }
  83.         }
  84.     }
  85. }
  86.  
  87.  
  88. /********************************************************************/
  89. /********************************************************************/
  90. lamerize(buf)
  91. char buf[];
  92. {
  93.     register int j,  count=0;
  94.     char out[MAXLAME];
  95.  
  96. #ifdef LAME_SRAND
  97.     time_t t;
  98.         srand((unsigned) time(&t));
  99. #else 
  100.         srand((unsigned) getpid());
  101. #endif
  102.  
  103.         for(j=0; j<strlen(buf); j++) {
  104.             if( buf[j]=='y' && buf[j+1]=='o' && buf[j+2]=='u') {
  105.                 out[count++]='U'; j+=2;
  106.             }
  107.             else if( buf[j]=='o' || buf[j]=='O') {
  108.                 if( rand()%3==1 ) {
  109.                     out[count++]='('; out[count++]=')';
  110.             } else out[count++]='0';
  111.             }
  112.             else if( buf[j]=='a' && buf[j+1]=='n' && buf[j+2]=='d'){
  113.                 out[count++]='&'; j+=2;
  114.             }
  115.             else if((buf[j]=='i' || buf[j]=='I')&&(rand()%5>=2)) {
  116.                 out[count++]='1';
  117.             }
  118.             else if( buf[j]=='l' && (rand()%3==1)) {
  119.                 out[count++]='|';
  120.             }
  121.             else if(buf[j]=='s'&&(buf[j+1]=='\0'||ispunct(buf[j+1]))){
  122.                 out[count++]='z'; out[count++]='z';
  123.             }
  124.             else if( (buf[j]=='e' || buf[j]=='E') &&(rand()%5 >= 3) ){
  125.                 out[count++]='3';
  126.             }
  127.             else if( rand()%5==1 ) out[count++]=toupper(buf[j]);
  128.             else out[count++]=buf[j];
  129.         }
  130.  
  131.     out[count]=NULL;
  132.     printf("%s", out);
  133.     return(1);
  134. }
  135.  
  136. /********************************************************************/
  137. /********************************************************************/
  138. usage()
  139. {
  140.  
  141.     printf("\n***\n*** The Lamer Filter, Version 2.7\n");
  142.     printf("***\n*** by zorgo <zorgo@gnu.ai.mit.edu>\n***\n***\n");
  143.     printf("*** Usage:\n");
  144.     printf("***   Starting LAME with no arguments will put it in continuous lamerize mode.\n");
  145.     printf("***   Use Control-C to quit.\n");
  146.     printf("***\n");
  147.     printf("***   Starting LAME with arguments will lamerize everything on\n");
  148.     printf("***   the command line, and then quit.\n");
  149.     printf("***\n");
  150.     printf("***   To lamerize a text file:\n");
  151.     printf("***  Unix:   cat in_file | lame > out_file\n");
  152.     printf("*** MSDOS:   type in_file | lame > out_file\n");
  153.     printf("***\n");
  154.     printf("***   To be lame in real time on IRC (ircII only):\n");
  155.     printf("***          /alias l /exec -out lame \"$0-\"\n");
  156.     printf("***          /l text_to_be_lamerized\n");
  157.     return(1);
  158. }
  159.